/*
 * Created on 2005-5-14
 * Window - Preferences - Java - Code Style - Code Templates
 */
package com.haoxi.gateway.common;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author Administrator
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class ListQueue implements Queue {
    /**
     * 默认最大长度
     */
    private static int DEFAULT_MAX_LENGTH = 100;
    
    /**
     * 默认名字
     */
    private static String DEFAULT_NAME = "def_name";
    
    /**
     * 保存对象的列表
     */
    private List list = new LinkedList();
    
    /**
     * 队列改变时的监听器列表
     */
    private List listChengeListener = new LinkedList();
    
    /**
     * 最大长度
     */
    private int maxLength;
    
    /**
     * if notifying locked obj is true
     */
    private boolean notifying = false;
    
    /**
     * Queue name
     */
    private String name;
    
    public ListQueue() {
        this(DEFAULT_MAX_LENGTH,DEFAULT_NAME);
    }
    
    public ListQueue(int length, String sName) {
        maxLength = length;
        name = sName;
    }
    
    /**
     * 插入一个队头元素
     * @see com.haoxi.sms.model.Queue#add(java.lang.Object)
     */
    public boolean add(Object obj) {
        return insert(0,obj);
    }

    /**
     * 减去队尾元素
     * @see com.haoxi.sms.model.Queue#sub()
     */
    public Object sub() {
        return removeLast();
    }

    /**
     * 如果长度为0，返回true
     * @see com.haoxi.sms.model.Queue#isEmpty()
     */
    public boolean isEmpty() {
        if(getLength() == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 返回队列长度
     * @see com.haoxi.sms.model.Queue#getLength()
     */
    public int getLength() {
        if(list == null) {
            return 0;
        } else {
            return list.size();
        }
    }

    /**
     * 清空所有对象
     * @see com.haoxi.sms.model.Queue#clear()
     */
    public int clear() {
        int oldLength = getLength();
        if(list != null) list.removeAll(list);
        return oldLength;
    }

    /**
     * 根据位置获得对象
     * @see com.haoxi.sms.model.Queue#getByPosition(int)
     */
    public Object getByPosition(int index) {
        if(list != null) {
            return list.get(index);
        }
        return null;
    }

    /**
     * 获得对象的位置
     * @see com.haoxi.sms.model.Queue#getPosition(java.lang.Object)
     */
    public int getPosition(Object obj) {
        if(list != null) {
            return list.indexOf(obj);
        }
        return 0;
    }

    /**
     * 插入一个对象
     * @see com.haoxi.sms.model.Queue#insert(java.lang.Object)
     */
    public boolean insert(int nIndex, Object obj) {
        if(list == null) list = new LinkedList();
        //不空的情况才插入
        synchronized(list) {
            if(isFull()) {
                return false;
            } else {
                list.add(nIndex,obj);
                //if not notify listner notify it
                if(!notifying) {
                    notifyAllQueueChange(listChengeListener);    
                }
                return true;
            }
        }
    }

    /**
     * 删除一个对象
     * @see com.haoxi.sms.model.Queue#remove(int)
     */
    public Object remove(int index) {
        if(list == null) return null;
        //不空的情况才删除 
        synchronized(list) {
            Object obj = null;
            if(list.size() > 0) {
                obj = list.remove(index);
//                //if not notify listner notify it
//                if(!notifying) {
//                    notifyAllQueueChange(listChengeListener);    
//                }
            }
            return obj;
        }
    }
    /**
     * @return 删除最有一个对象（只限LinkedList）
     */
    private Object removeLast() {
        if(list == null) return null;
        Object obj = null;
        //不空的情况才删除 
        synchronized(list) {
            if(list.size() > 0) {
                obj = ((LinkedList)list).removeLast();
//                //if not notify listner notify it
//                if(!notifying) {
//                    notifyAllQueueChange(listChengeListener);    
//                }
            }
            
            return obj;
        }
    }
    
    /**
     * 返回队列是否有空位置
     */
    public boolean isFull() {
        if(getLength() >= getMaxLength()) {
            return true;
        } else {
            return false;
        }
    }
    
    /**
     * @return 剩余的空位
     */
    public int getRemains() {
        return getMaxLength() - getLength();
    }

    /**
     * @return 最大长度
     */
    public int getMaxLength() {
        return maxLength;
    }
    /**
     * @param 设置最大长度
     */
    public boolean setMaxLength(int maxLength) {
        this.maxLength = maxLength;
        return true;
    }
    
    /**
     * @return 队列的快照（拷贝对象）
     */
    public Object[] getQueueSnap() {
        if(list != null) {
            synchronized(list) {
                Object[] a = list.toArray();
                int size = a.length;
                if(size <= 0) {
                    return null;
                } else {
                    Object[] b = new Object[size];
                    System.arraycopy(a,0,b,0,size);
                    return b;
                }
            }
        } else {
            return null;
        }
    }
    
    /**
     * 通知所有“改变监听器”队列已经改变
     * @param list 监听器列表
     */
    private void notifyAllQueueChange(List list) {
        if(list != null) {
            synchronized(list) {
                notifying = true;
                //激活所有对象
                Iterator it = list.listIterator();
                Object obj = null;
                while(it.hasNext()) {
                    obj = it.next();
                    synchronized(obj) {
                        obj.notifyAll();
                    }
                }
                notifying = false;
            }
        }
        return;
    }
    
    /**
     * @param run 队列改表监听器
     * @return 监听器的编号
     */
    public int addChengeListener(Runnable run) {
        if(listChengeListener == null) listChengeListener = new LinkedList();
        int nIndex = 0;
        synchronized(listChengeListener) {
            listChengeListener.add(run);
            nIndex = listChengeListener.size();
        }
        return nIndex;
    }
    /**
     * @param run 需要删除的监听器
     */
    public void removeChengeListener(Runnable run) {
        if(listChengeListener != null) {
            synchronized(listChengeListener) {
                listChengeListener.remove(run);
            }
        }
    }
    /**
     * 删除所有改变时的监听器
     */
    public int removeAllChengeListener() {
        int size = 0;
        if(listChengeListener != null) {
            synchronized(listChengeListener) {
                size = listChengeListener.size();
                listChengeListener.clear();
            }
        }
        return size;
    }
    
    /**
     * get/set name
     */
    public String getName() {
        return this.name;
    }
    public void setName(String sName) {
        this.name = sName;
    }
}
